/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package op;

import core.FiltraLigacao;
import elemento.ClienteTelefone;
import in_out.IOUtils;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import op.element.LigacaoHorario;

/**
 *
 * @author Jônatas
 */
public class Utils {

    public static ContaTelefonica aplicaFiltros(ContaTelefonica contaOriginal,
            List<FiltraLigacao> filtros) {

        if (contaOriginal == null || filtros == null || filtros.isEmpty()) {
            return contaOriginal;
        }

        ContaTelefonica novaConta = contaOriginal;

        for (FiltraLigacao filtro : filtros) {
            novaConta = filtro.execute(novaConta);
        }


        return novaConta;
    }

    public static List<Ligacao> getLigacoesFromDestino(Telefone destino, ContaTelefonica contaOriginal) {
        List<Ligacao> ligacoes = new ArrayList<Ligacao>();

        for (Ligacao lig : contaOriginal.getLigacoes()) {

            if (lig.getDestino().equals(destino)) {
                ligacoes.add(lig);
            }

        }
        return ligacoes;
    }

    public static List<Ligacao> getLigacoesFromOrigem(Telefone origem, ContaTelefonica contaOriginal) {
        List<Ligacao> ligacoes = new ArrayList<Ligacao>();

        for (Ligacao lig : contaOriginal.getLigacoes()) {

            if (lig.getNumeroDeOrigem().equals(origem)) {
                ligacoes.add(lig);
            }

        }
        return ligacoes;
    }

    public static List<Ligacao> getLigacoes(LigacaoResumida ligResumida,
            ContaTelefonica contaOriginal) {

        List<Ligacao> ligacoes = new ArrayList<Ligacao>();

        for (Ligacao lig : contaOriginal.getLigacoes()) {

            Telefone origem = ligResumida.getOrigem();
            Telefone destino = ligResumida.getDestino();
            boolean aCobrar = ligResumida.isIsACobrar();

            if (lig.getNumeroDeOrigem().equals(origem) && lig.getDestino().equals(destino)
                    && aCobrar == lig.isACobrar()) {
                ligacoes.add(lig);
            }

        }
        return ligacoes;
    }

    public static ContaTelefonica ligacoesHora(ContaTelefonica contaOriginal,
            int horaInicio, int minutoInicio, int horaFim, int minutoFim) {

        List<Ligacao> ligacoesOriginais = contaOriginal.getLigacoes();
        List<Ligacao> ligacoesHora = new ArrayList<Ligacao>();


        for (Ligacao ligacao : ligacoesOriginais) {

            Date date = ligacao.getDataOrigemLigacao();

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);

            int horaLigacao = calendar.get(Calendar.HOUR_OF_DAY);
            int minLigacao = calendar.get(Calendar.MINUTE);

            if (horaInicio < horaFim) {

                if (horaInicio < horaLigacao || ((horaInicio == horaLigacao) && (minutoInicio <= minLigacao))) {
                    if (horaLigacao < horaFim || ((horaFim == horaLigacao) && (minLigacao < minutoFim))) {
                        ligacoesHora.add(ligacao);
                    }
                }

            } else if (horaInicio > horaFim) {

                if ((horaInicio < horaLigacao) || ((horaInicio == horaLigacao) && (minutoInicio <= minLigacao))
                        || ((horaLigacao < horaInicio) && ((horaLigacao < horaFim) || ((horaLigacao == horaFim) && (minLigacao < minutoFim))))) {
                    ligacoesHora.add(ligacao);
                }

            } else {

                if (minutoInicio < minutoFim) {

                    if ((horaLigacao == horaInicio) && (minutoInicio <= minLigacao) && (minLigacao < minutoFim)) {
                        ligacoesHora.add(ligacao);
                    }

                } else if (minutoInicio > minutoFim) {

                    if (horaInicio != horaLigacao) {
                        ligacoesHora.add(ligacao);
                    } else {
                        if (minutoInicio <= minLigacao) {
                            ligacoesHora.add(ligacao);
                        }
                    }

                }


            }


        }

        ContaTelefonica resposta = new ContaTelefonica(contaOriginal.getContaMensal());
        resposta.setLigacoes(ligacoesHora);
        return resposta;
    }

    public static List<LigacaoDDD> getLigacaoDDD(List<LigacaoResumida> ligacoes) {

        Map<String, LigacaoDDD> ligacoesDDD = new HashMap<String, LigacaoDDD>();

        for (LigacaoResumida lig : ligacoes) {
            String ddd = lig.getDestino().getDdd();

            if (ddd == null || ddd.isEmpty()) {
                continue;
            }

            if (!ligacoesDDD.containsKey(ddd)) {
                LigacaoDDD ligDDD = new LigacaoDDD(ddd);
                ligDDD.addLig(lig);
                ligacoesDDD.put(ddd, ligDDD);
            } else {
                ligacoesDDD.get(ddd).addLig(lig);
            }
        }

        List<LigacaoDDD> resp = new ArrayList<LigacaoDDD>();

        for (String key : ligacoesDDD.keySet()) {
            resp.add(ligacoesDDD.get(key));
        }

        Collections.sort(resp);

        return resp;
    }

    public static boolean insertMultipleTelefones(File csv) {

        List<ClienteTelefone> clientes = null;

        try {
            clientes = IOUtils.getClientes(csv);
        } catch (IOException ex) {
            return false;
        }
        try {
            IOUtils.insertClients(clientes);
        } catch (SQLException ex) {
            return false;
        }

        return true;


    }

    public static List<LigacaoHorario> getLigacaoHora(List<Ligacao> ligacoes) {

        Map<Integer, LigacaoHorario> ligacoesHorario = new HashMap<Integer, LigacaoHorario>();

        Calendar cal = Calendar.getInstance();

        for (Ligacao lig : ligacoes) {

            if(lig.getDataOrigemLigacao() == null) {
                continue;
            }

            cal.setTime(lig.getDataOrigemLigacao());
            Integer inicio = new Integer(cal.get(Calendar.HOUR_OF_DAY));

            if (!ligacoesHorario.containsKey(inicio)) {
                LigacaoHorario ligacaoHorario = new LigacaoHorario(inicio.intValue());
                ligacoesHorario.put(inicio, ligacaoHorario);
            }

            LigacaoHorario ligacaoHorario = ligacoesHorario.get(inicio);
            ligacaoHorario.addLigacao(lig);

        }

        List<LigacaoHorario> listLigacoesHorario = new ArrayList<LigacaoHorario>();

        for (Integer key : ligacoesHorario.keySet()) {
            listLigacoesHorario.add(ligacoesHorario.get(key));
        }

        Collections.sort(listLigacoesHorario);

        return listLigacoesHorario;

    }
}
